﻿#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<assert.h>
#include<math.h>
//#define _CRT_SECURE_NO_WARNINGS 1
//int main()
//{
//
//	printf("\"");
//	return 0;
//}

//int main()
//{
//	int a, b;
//	printf("请选择：1：好好学习   0：不学习\n");
//	scanf("%d", &a);
//	switch (a)
//	{
//	case 1:
//		printf("拿offer走上人生巅峰");
//		break;
//	case 0:
//		printf("回家卖红薯");
//		break;
//	}
//	return 0;
//}

//int ADD(int x, int y)
//{
//	int z;
//	return z = x + y;
//}
//int main()
//{
//	int a, b;
//	printf("请输入两个操作数\n");
//	scanf("%d%d", &a, &b);
//	printf("%d",ADD(a,b));
//	return 0;
//}

//int main()
//{
//	typedef int L;
//	L a = 5;
//	printf("%d", a);
//	return 0;
// }

//#include <stdio.h>
//void test()
//{
//	int i = 0;
//	i++;
//	printf("%d ", i);
//}
//int main()
//{
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		test();
//	}
//	return 0;
//}
//比较这两组代码，可以发现static的功能
//上面一组的i分为两块，且每次出函数，函数中的i都会被销毁
//而用static修饰的i得到了保留

//#include <stdio.h>
//void test()
//{
//	//static修饰局部变量
//	static int i = 0;
//	i++;
//	printf("%d ", i);
//}
//int main()
//{
//	int i = 0;
//		for (i = 0; i < 10; i++)
//		{
//			test();
//		}
//		return 0;
//	}

//int main()
//{
//	static int a;
//	printf("%d", a);
//	return 0;
//}
//#define ADD(x,y) x+y
//int main()
//{
//	int a, b;
//	scanf("%d%d", &a, &b);
//	printf("%d", ADD(a, b));
//	return 0;
//}

//int main()
//{
//	int day=0;
//	switch (day)
//	{
//
//	case 1:
//			printf("1");
//			break;
//	case 2:
//			printf("2");
//			break;
//		case 3:
//			printf("3");
//			break;
//		case 4:
//			printf("4");
//			break;
//		case 5:
//			printf("5");
//			printf("6");
//			break;
//	}
//		
//	return 0;
//}
//int main()
//{
//int x, y;
//for (x = 0, y = 0; x=0; x++, y++)
//{
//	printf("hehe\n");
//}
//return 0; }

//对比这两段代码：发现如果只写一个=那么判断语句的判断效果失效
//int main()
//{
//	int i = 0,k = 0;
//	for (i = 0, k = 0; k = 0; i++, k++)
//		k++;
//	return 0;
//}
//
//练习计算：n的阶层
//#include<stdlib.h>
//#include<time.h>
//int main()
//{
//	int a = 1,n,count=1;
//	scanf("%d", &n);
//	for (a;a<=n;a++)
//	{
//		count *= a;
//	}
//	printf("%d\n", count);
//	randomize();//原型是void randomize:我发现不加void直接写函数名是惯用法//用不了
//	printf("%d\n%d\n%d\n%d", rand(), rand(), rand(), rand());
//	return 0;
//}

//计算1！+2！+3！...+n！
//int main()
//{
//	int a = 1,n;
//	long m = 0;  int count = 1;
//	scanf("%d", &n);
//	for (a,count=1; a <=n; a++)
//	{
//		count = 1;
//		for (int i = 1; i <= a; i++)
//		{
//			 count *= i;
//		}
//		m += count;//为什么......搞错了，没毛病
//	}
//	printf("%d%ld", count,m);
//	return 0;
//}

//在一个有序数组中查找具体的某个数（注意！！！！！！！！！）
//search(int x, int arr[10], int n)
//{
//	for (int i = 0; i < n; i++)
//	{
//		if (x == arr[i])
//		{
//			printf("查询结果为：%d", arr[i]);
//			break;
//		}
//		if (i == n - 1)
//		{
//			printf("查询无果，请重新输入");
//		}
//	}
//
//}
//
//int main()
//{
//	int n,x;
//	int shu[10] = { 0 };
//	printf("请输入数组的个数");
//	scanf("%d", &n);
//	printf("\n");
//	printf("请给数组赋值");
//	for (int i = 0; i < n; i++)
//	{
//		scanf("%d", &shu[i]);
//	}
//	printf("\n");
//	printf("请输入要查询的数");
//	scanf("%d", &x);
//	search(x, (int*) shu[10], n);//参数没传进去
//
//	return 0;
//}

//search(int x, int arr[10], int n)
//{
//	for (int i = 0; i < n; i++)
//	{
//		if (x == arr[i])
//		{
//			printf("查询结果为：%d", arr[i]);
//			break;
//		}
//		if (i == n - 1)
//		{
//			printf("查询无果，请重新输入");
//		}
//	}
//
//}
////传地址当然可以，那我如何将整个数组传过去
//int main()
//{
//	int n, x;
//	int shu[10] = { 0 };
//	printf("请输入数组的个数");
//	scanf("%d", &n);
//	printf("\n");
//	printf("请给数组赋值");
//	for (int i = 0; i < n; i++)
//	{
//		scanf("%d", &shu[i]);
//	}
//	printf("\n");
//	printf("请输入要查询的数");
//	scanf("%d", &x);
//	search(x, shu, n);
//
//	return 0;
//}
//#include <windows.h>
//int main()
//{
//	/*int n, m;*/
//		char arr[30] = {' '};
//		printf("%s", arr);      //此时出现了一个问题，\0会是打印中断
//		for (int x = 0, y = 29; x <= y; x++, y--)//第一个错误版
//		{
//			arr[x] = '#'; arr[y] = '#';
//			printf("%s", arr);
//			Sleep(1000);
//		}
//	return 0;
//}

//#include <windows.h>
//int main()
//{
//	char arr[35] ="#############################";
//	printf("%s", arr);
//	for (int x = 0, y = 29; x <= y; x++, y--)
//	{
//		printf("\n");
//		arr[x] = '*'; arr[y] = '*';//但这代码太LOW了，低端
//		printf("%s", arr);
//		Sleep(1000);
//	}
//	return 0;
//}

//#include<windows.h>
//#include<string.h>
//int main()
//{
//	char arr[] = "########################################";
//	int left = 0;
//	int right = strlen(arr) - 1;
//	/*printf("\n");*/
//	for (left, right; left <= right; left++, right--)
//	{
//		arr[left] = (arr[right] = '*');//比上段代码强了很多，但这还有个缺陷，无法打印指定内容
//		printf("%s", arr);
//		Sleep(1000);
//		printf("\n");
//	}
//	return 0;
//}

//#include<windows.h>
//#include<string.h>
//int main()
//{
//	char arr[] = "########################################";
//	int left = 0;
//	int right = strlen(arr) - 1;
//	/*printf("\n");*/
//	for (left, right; left <= right; left++, right--)
//	{
//		arr[left] =arr[right] = '*';//这种写法也行
//		printf("%s", arr);//如果要指定放的话，那么就再创一个数组
//		Sleep(1000);
//		printf("\n");
//	}
//	return 0;
//}

//二分查找
//int main()
//{
//	int arr[] = { 1,3,4,5,6,7,8,9,10,12 };
//	int left = 0; 
//	int right = sizeof(arr) / sizeof(arr[0])-1;
//	int x; int mid = 0;
//	printf("请输入要查找的数"); 
//	scanf("%d", &x);
//
//	while(left<=right)
//	{
//		mid = (left + right) / 2;
//		if (x < arr[mid])
//		{
//			right = mid - 1;
//
//		}
//		else if (x > arr[mid])
//		{
//			left =mid+1;
//		}
//		else
//		{
//			printf("查找成功：%d", arr[mid]);
//			break;
//		}
//	}
//	if(left<right)
//	{
//		printf("查找失败");
//	}
//	return 0;
//}

//猜数字小游戏
//#include<string.h>
//#include<time.h>
//#include<stdlib.h>
//int main()
//{
//	printf("%d\n%d\n%d\n%d", rand(),rand() ,rand(), rand());
//	//实验：rand()（如果在括号中输入数字，那么无效，等价于rand（））
//
//	return 0;
//}

//#include<time.h>
//#include<windows.h>
//int main()
//{
//	for (int i = 0; i < 100; i++)
//	{
//		printf("%ld\n", (long)time());
//		Sleep(100);
//	}
//	
//	return 0;
//
//}
//做猜数小游戏
//#include<time.h>
//#include<windows.h>
//int main()
//{
//	int n = 0;
//	srand((unsigned)time(NULL));
//	printf("请猜一个1~10的数字");
//	int gart = rand() % 10 + 1;
//	while (scanf("%d", &n))
//	{
//		if (n == gart)
//		{
//			printf("恭喜你，猜对了");
//			break;
//		}
//		else if (n < gart)
//		{
//			printf("猜小了，再来一次");
//		}
//		else
//		{
//			printf("猜大了，再来一次");
//		}
//	}
//	return 0;
//}

//关机程序
#include<string.h>
//#include<stdio.h>
//int main()
//{
//	char a[20];
//	printf("请在60s内输入：我是猪   否则电脑关机  \n ->请输入:");
//	system("shutdown -s -t 60");
//	again:
//	scanf("%s", &a);
//	if (0 == strcmp(a, "我是猪"))
//	{
//		system("shutdown -a");
//	}
//	else
//	{
//		printf("输入错误，请再次输入：\n");
//		goto again;
//	}	
//	return 0;
//}
//#include<stdlib.h>
//int main()
//{
//	system("color 0A");
//	system("pause")
//	return 0;
//}

//strcpy函数的应用
//#include<string.h>
//int main()
//{
//	char arr[20] = "L love you foreverle";
//	char arr2[25] = { "#######################" };//
//	strcpy(arr2, arr);//在原空间有\0的情况下，末尾的\0也会拷贝
//	printf("%s", arr2);//而如果空间完全满了就考不过去
//	return 0;
//}

//#include<string.h>
//int main()
//{
//	char a[30];
//
//	memset(a, 8, 25);
//	return 0;
//}

//练习
//写一个函数判断是数否为素数
//void ok(int x)
//{
//	int n = 0;
//	for (int i = 1; i <= x; i++)
//	{
//		if (x%i==0)
//		{
//			n++;
//		}
//		if(i==x)
//		if (n == 2)
//			printf("为素数");
//		else
//			printf("不是素数");
//	}
//
//}
//int main()
//{
//	int p = 0;
//	scanf("%d", &p);
//	ok(p);
//	return 0;
//}

//判断是否为闰年
//int lian(int n)
//{
//	if (n % 4 == 0)
//	{
//		
//		if(n % 100 != 0)
//		{ 
//			printf("为闰年");
//			return 0;
//		}		
//
//		if (n % 400 == 0)
//			printf("为闰年");
//	}
//}
//int main()
//{
//	int s = 0;
//	scanf("%d", &s);
//	lian(s);
//	return 0;
//}

//函数的链式访问
//#include<string.h>
//int main()
//{
//	int a = 11;
//	int n = printf("%d", a);
//	printf("%d", n);
//	printf("%d", printf("%d\nooo", a));//为什么返回值是三
//	//极有可能是\0//返回的是''号里面的
//	return 0;
//}
//关于字符串操作函数的链式访问
//#include<string.h>
//int main()
//{
//	char a[20] = "abcdef";
//	int n = strlen(strcat(a, "ghr"));
//	printf("%d", n);
//	printf("%s", a);
//
//	return 0;
//}


//假象一个递归的例子
//void gui(int n,int m)
//{
//
//	if (n <= 500)
//	{
//		n++; m += 2;
//		gui(n, m);
//	}
//	printf("%d\t%d\n", n, m);
//
//}//递归的本质就是由结果推开始，逆过程
//int main()
//{	
//	int n = 0,m=0;
//	gui(n,m);
//	return 0;
//}

//按顺序打印一个数的各位
//void my_printf(int num)
//{
//	if (num !=0)//位置没摆好
//	{
//		printf("%d", num%10);
//		num = num / 10;
//		my_printf(num);
//	}
//	
//}
//int main()
//{
//	int num = 1234;
//	my_printf(num);
//	return 0;
//}
//
//void my_printf(int num)
//{
//	//printf("%d ", num % 10);
//	if (num>9)
//	{	
//		my_printf(num/10);
//	}
//	printf("%d ", num % 10);
//	
//	//递归中顺序很重要，递归函数一定要放在条件语句中
//}
////规则：1.处理   2.判断并递归    3.执行
////执行的顺序是从底层开始的,执行的是逆过程
////缺陷，第一层会有问题，因为数据一进来就被处理了，无发执行以源数据为基础
//
////如果按照：1.执行   2.处理   3.判断并递归；；那么在此处打印顺序不对（但有些情况就可以）
//
////那么把处理放在条件句里面即1.执行  2.判断+处理+递归(就要特别注意调函数和处理的位置)，可这样还是先处理底层
////实际上就同上一种情况（都是正序）
////先执行不处理则无法终结，
////因按照1.判断   2.处理   3.执行的顺序（这就成了正序）逆逆得正（注意执行不放在判断内，否则最后一种情况无法执行）
////但这里还是有问题4打不出来
//
////最后改成my_printf(num/10)递归从未处理过数据，他只是将有规律变化的数据传过去供供使用
//int main()
//{
//	int num = 1234;
//	my_printf(num);
//	return 0;
//}

//在不创建临时变量的情况下，计算字符串长度
//#include<string.h>
//void leng(char *x)
//{
//	static int n = 0;
//	if(*x!='\0')
//	{
//		leng(x+1);
//		n++;
//	}
//	printf("%d\n",n);
//}
//
//int main()
//{
//	char a[20] = "abcdefg";
//	leng(a);
//	return 0;
//}//这个可以，但还有一种大胆而神奇的编法

//int len(const char *n)
//{
//	if (*n != '\0')
//	{
//		return 1 + len(n + 1);
//	}
//	else
//		return 0;
//}
//int main()
//{
//	char arr[20] = "abcdefj";
//	int num = len(arr);
//	printf("%d", num);
//	return 0;
//}

//真的理解后，递归真的方便，可以当循环用

//用递归实现求第n个斐波那契数

//int bo(int n)
//{
//	if (n <=2)
//	{
//		return 1;
//	}
//	else
//		return bo(n-1)+bo(n-2);
//
//}
//这里n代表的是次数，而不是数字
//int main()
//{
//	int a;
//	scanf("%d", &a);
//	printf("%d", bo(a));
//	return 0;
//}

//用数组实现
//int main()
//{
//	int n; int arr[50] = { 1,1 };
//	scanf("%d", &n);
//	for (int i = 0;i<n; i++)
//	{
//		arr[i + 2] = arr[i] + arr[i + 1];
//	}
//	printf("%d", arr[n - 1]);
//	return 0;
//}


//不用数列和递归实现斐波那契数
//int main()
//{
//	int n = 0, m = 1, num = 1, add=0;
//	scanf("%d", &n);
//	for (int i = 0; i <(n-2)/3+1; i++)//每执行一次就可以算出接下来三个数
//	{
//		int x = (n - 2) / 3 + 1;
//		add = num + m;//一二已初始化
//		num = add + m;
//		m = add + num;
//	}
//	if (n % 3 == 0)
//		printf("%d", add);
//	if ((n - 1) % 3 == 0)
//		printf("%d", num);
//	if ((n - 2) % 3 == 0)
//		printf("%d",  m);
//	return 0;
//
//}
//int main()
//{
//	int n = 10;
//	int arr[5] = {3};
//	char arr2[5] = { };
//	return 0;
//}
//实验位操作符
//#include<math.h>
//int main()
//{
//	int a = 3;
//	printf("%d\n%lf", a << 2,pow(2,3));
//	return 0;     //右移几位，就是*2的几次方
//}

//int main()
//{
//	int a = -1;
//	printf("%d", a>>1);
//	return 0;//是算数移位
//}

//位操作符
//int main()
//{
//	int num = 1;
//	int num2 = 3;
//	printf("%d\n", num^num2);//规则：同则为0；不同为1。
//	printf("%d\n", num&num2);//都为一则为一，有零则为0。
//	printf("%d\n", num|num2);//有一就为一。
//	return 0;
//}

//编写代码实现计算一个数二进制存在内存里的1的个数
//int main()
//{
//	int a,count=0;
//	scanf("%d", &a);
//	do
//	{
//		if (a % 2 == 1)
//			count++;
//	} 
//	while (a = a / 2);//除2的作用就相当于向右移一位
//	printf("%d", count);
//	return 0;
//}
////注意，do  while的结构就相当于
//while (a)
//{
//	if ()
//		;
//	处理
//}


//用移位操作符实现
//int main()
//{
//	int a, count=0;
//	scanf("%d", &a);//为什么这里a的移位无效
//	for (int i = 0; i < 32;a>>1,i++)
//	{
//		if (a % 2 == 1)
//			count++;
//	}
//	printf("%d", count);
//	return 0;
//}
//int main()
//{
//	int a, count = 0;
//	scanf("%d", &a);//为什么这里a的移位无效
//	for (int i = 0; i < 32; i++)
//	{
//		if (a % 2 == 1)
//			count++;
//		a=a >> 1;//对比上下两段代码后，在a>>1一出来后出现了一段报错
//	}//”>>“: 未使用表达式结果          所以我就错在没给a赋值
//	printf("%d", count);
//	return 0;
//}

//位操作符和移位操作符结合
//int main()
//{
//	int n,count=0;
//	scanf("%d", &n);
//	for (int i = 0; i < 32; i++)
//	{
//		if (((n >> i)&1) == 1)
//			count++;
//	}
//	printf("%d", count);
//	return 0;
//}

//进一步优化
//int main()
//{
//	int n,count=0;
//	scanf("%d", &n);
//	for (int i = 0; i < 32; i++)
//	{
//		if (((n >> i)&1) == 1)
//			count++;
//		if ((n >> i) == 0)
//			break;
//	}
//	printf("%d", count);
//	return 0;
//}

//极简版优化
//妙啊
//int main()//这种方法巧妙用了（-1完成一次计数）在用&将最后的1清掉
//{
//	int n, count = 0;
//	scanf("%d", &n);
//	while(n)
//	{
//		count++;
//		n = (n - 1) & n;
//	}
//	printf("%d", count);
//	return 0;
//
//}

//int main()
//{
//	int a = 13;
//	printf("%d",a>>1);
//	return 0;
//}

//#include <stdio.h>
//void test1(int arr[])
//{
//	printf("%d\n", sizeof(arr));//(2)
//}
//void test2(char ch[])
//{
//	printf("%d\n", sizeof(ch));//(4)
//}
//int main()
//{
//	int arr[10] = { 0 };
//	char ch[10] = { 0 };
//	printf("%d\n", sizeof(arr));//(1)
//	printf("%d\n", sizeof(ch));//(3)
//	test1(arr);
//	test2(ch);
//	return 0;
//}

//int main()
//{
//	char a = 0xb6;
//short b = 0xb600;
//int c = 0xb6000000;
//if (a == 0xb6)
//printf("a");
//if (b == 0xb600)
//printf("b");
//if (c == 0xb6000000)
//printf("c");
//return 0; }

//int main()
//{
//	char c = 1;
//	printf("%u\n", sizeof(c));
//	printf("%u\n", sizeof(+c));
//	printf("%u\n", sizeof(!c));
//	return 0;
//}
//经典的整型提升的代码

//算数运算需要在同一类型数间进行，否则进行不了
//检验代码如下
//int main()
//{
//	int a = 2;
//	float b = 2.0;
//	printf("%d", a + b);
//	return 0;
//}

//关于整型提升的奇怪知识
//int main()
//{
//	unsigned char a = -1;
//	//如果是 char a=-1;的话就是 -1
//	printf("%d",a);//原：10000001  反:11111110  补：11111111 
//	return 0;
//}
//如果打印有符号数，且最高位是1,那么整形提升后左边全部补1
//无符号则直接全补0

//设计一个程序检验：整型提升的是补码还是源码
//int main()
//{
//	unsigned char a = -1;   //原：10000001    补：11111111     11111111 11111111 10000000
//	printf("%u\n", a);    //这打印的是整型提升后的补码   00000000 00000000 10000000     11111111 
//	printf("%d", a);      //整型提升后换为源码再打印     10000000 00000000 01111111
//	char a = -1;   
//	printf("%u\n", a);     
//	printf("%d", a);
//	return 0;
//}
//经确定，%u打印，打印的是32位，按补码来识别，整型提升是补码
//unsigned char a = -1  在内存中的放的方式还是10000001   （sign和unsign决定看待最高位的方式）   类型决定开辟的大小
//unsigned  和  %u 决定了大小是两种方式，没有一点关系


//想试一试%d打印是不是不会出错呢？
//int main()
//{
//	char a = 128;
//	char b = 4;
//	char c = a + b;
//	printf("%d", a + b);  //为-4
//	return 0;
//}

//因为128或-128取补码后，后8比特位都为0，再者相加后要求源码，（都是在32位的条件下）所以逆过来
//int main()
//{
//	char a = 128;    //为什么128+1=-127
// 	char b = 4;
//	char c = a + b;
//	printf("%d", a + b);
//	return 0;
//}

//252在zhar中是怎么存的
//int main()
//{
//	char a = 252;     //存在内存中是源码：1111100  补码：10000100   为-4
//	char b = a + 4;    //完全可以解释了4的源码：00000100   补：01111100   相加为0
//	return 0;
//}

//超过256的数可不可以存进去
//int main()
//{
//	char a = 266;
//	printf("%d", a); //(可以但是会截断)
//	return 0;
//}

//指针可以运算吗？   比如加减
//int main()
//{
//	int a = 1;
//	int b = 5;
//	int *p = &a;//+ &b;
//	printf("%p\n%p\n%p",&a,&b,p);
//	return 0;
//
//}


//关于结构体
//struct person
//{
//	int f;
//	char b;
//	int arr[5];
//	int *d;
//}a,b;
//
//int main()
//{
//	int n = 9;
//	struct person a = { 8,'p',{1,2,3,4,5},&n };
//	printf("%d	%c	%d	%p", a.f, a.b, a.arr, a.d);
//	return 0;
//}

//结构体镶嵌
//struct womy
//{
//	int age;
//	char u[10];
//};
//struct person
//{
//	int f;
//	char b;
//	int arr[5];
//	int *d;
//	struct womy l;
//}a, b;
//
//int main()
//{
//	int n = 9;
//	struct person a = { 8,'p',{1,2,3,4,5},&n,{19,{"abcdef"}} };
//	printf("%d	%c	%d	%p  %d	%s", a.f, a.b, a.arr, a.d,a.l.age,a.l.u);
//	return 0;
//}

//结构体传参
//struct womy 
//{
//	int age;
//	char arr[20];
//}l;
//void my_print(struct womy *);
//
//int main()
//{
//	struct womy l = { 19,"songyucheng" };
//
//	//struct womy *m=
//	my_print(&l);
//	return 0;
//}
//void my_print(struct womy *p)
//{
//	printf("%d	%s	%d	%s", p->age, p->arr,(*p).age,(*p).arr);
/*}    */                                //（）不可省略，不然优先级会出错

//关于线性表
//int main()
//{
//	list 
//
//	return 0;
//
//}
//int main()
//{
//	int i = 0;
//	int sum = 0;//保存最终结果
//	int n = 0;
//	int ret = 1;//保存n的阶乘
//	scanf("%d", &n);
//	for (i = 1; i <= n; i++)
//	{
//		int j = 0;
//		ret = 1;
//		for (j = 1; j <= i; j++)
//		{
//			ret *= j;
//		}
//		sum += ret;
//	}
//	printf("%d\n", sum);
//	return 0;
//}
//代码1
//void test1()
//{
//	int n = 10;
//	int m = 20;
//	int *p = &n;
//	*p = 20;//ok?
//	p = &m; //ok?
//}
//void test2()
//{
//	//代码2
//	int n = 10;
//	int m = 20;
//	const int* p = &n;
//	*p = 20;//ok?
//	p = &m; //ok?
//}
//void test3()
//{
//	int n = 10;
//	int m = 20;
//	int *const p = &n;
//	*p = 20; //ok?
//	p = &m;  //ok?
//}
//int main()
//{
//	测试无cosnt的
//	test1();
//	测试const放在*的左边
//	test2();
//	//测试const放在*的右边
//	test3();
//	return 0;
//}
//通过这段代码，搞清楚const 的作用

//模拟实现strlen函数
//#include<string.h>
//void my_strlen(const char *a)
//{
//	//补一个  assert(a!=NULL)才更严谨
//	int i = 0;
//	while (*a != 0)
//	{
//		i++;
//		a++;
//	}
//	printf("%d", i);
//}
//
//int main()
//{
//	char zi[] = "woshisongyucheng";
//	printf("%d\n",strlen(zi));
//	my_strlen(zi);
//	return 0;
//}
//int main()
//{
//	char a[5] = { "abcdefg" };
//	printf("%s", a);
//	//溢出和满是一个道理都没了\0打印了个未知
//	return 0;
//}

//int main()
//{
//	int *p=0;
//	int a = 10;
//	int b;
//	//p = &a;
//	b = *p;
//	printf("%p	%d	%d	%p",p,a,b,&a);
//	return 0;
//}
//指针的初始化竟然分开了，但的确可以


//对数组元素的访问比如3[a]与a[3]是等效的
//天啊，我真是孤陋寡闻啊     []取下标操作符
//int main()
//{
//	int a[4] = {1,3,5,0};
//	printf("%d", 2[a]);
//	return 0;
//}
//C语言中数组和下标可以互换，是由于数组下标的指针定义决定的
//取下标操作符的操作数是可以互换的

//关于在函数内部使用malloc
#include<stdlib.h>
void fun(int **n)
{
	*n = (int *)malloc(8);
}

//int main()
//{
//	int *p;
//	int arr[2] = { 2,3 };
//	fun(p);           //传参就不行,会报错
//	p = arr;         //使用了未初始化的局部变量“p”
//	printf("%d	%d",*p,*(p+1));
//	return 0;
//}
//int main()
//{
//	int *p;
//	int arr[2] = { 2,3 };
//	fun(&p);           
//	p = arr;         
//	printf("%d	%d", *p, *(p + 1));
//	return 0;
//}


//我又孤陋寡闻了，结构体还有这种写法
//struct abt
//{
//
//	int age;
//	char name[20];
//	int arr[10];
//
//}pb,pa;      //可以这样定义
//int main()
//{
//	pb.age = 19;
//	pa.age = 20;
//	//pa.name = {"songyu"};
//	strcpy(pa.name, "songyuchen");
//	//都错了，字符数组不可以这样
//	//pa.arr = {1,2,5,4,6 };
//	//pa = { 30,{"song"}, {1,2,3,4,5} };      //直接用变量的初始化方式不行
//	//pa = { .age = 30 };                     //
//	struct abt pa = { 30,{"song"}, {1,2,3,4,5} };
//	struct abt pb = { .age = 50,.arr = {5,2,0} };  //甚至可以不完全初始化
//	//struct abt pa = { name:"songyuc", };     //第三种编译方式在这个编译器下通不过
//	//struct abt pa = { age:0 };
//	////pa->age = 19;
//	
//	//!!!!   重大发现：当我的代码中 struct abt pa;和pa.arr共存时那么无struct abt的部分都是无效的
//	return 0;
//}

//struct abt wome   //！！！！！！！！   我的一直的一个错误，不可以这样定义
//{
//	int age;
//	char [20];
//};
//int main()
//{
//	wome.age = 10;
//	return 0;
//}


//孤陋寡闻了
//typedef struct abt
//{
//	int arr[5];
//	char name[30];
//	int age;
//}*pa,pb;
//         //pa 等价于struct abt *      pb等价于struct abt 
//int main()
//{
//	pb jie = { {1,2,3,4,5},"songyuchen",19 };
//	pa zhi = &jie;
//	printf("%d	%d	%s", zhi->age, zhi->arr[3], zhi->name);
//	printf("\n%d	%d	%s", jie.age, jie.arr[2], jie.name);
//	
//	return 0;
//}

//判断大小端
//int main()
//{
//	int a = 1;
//	char * b = &a;
//	if (*b == 0)
//		printf("大端");
//	else
//		printf("小端");
//
//		printf("%d", *b);
//	return 0;
//}

//格式不严谨，还是强制类型转换一下

//union ap
//{
//	int b;
//	char a;
//
//}c,b;
//int main()
//{
//	//union ap;
//	c.b = 1;
//
//	printf("%d	%c",c.b,c.a );
//	return 0;
//}


//忽然想起来了结构体的另一种定义方式
//struct
//{
//	int a;
//	char b[15];
//}p,pa,*pb;
////这样也可以定义     缺陷就是只能一次性定义，因为没有类型名
//int main()
//{
//	p.a = 10;
//	pb = &pa;
//	strcpy(p.b,"songyucheng");
//	pb->a = 10;
//	printf("%d", pb->a);
//	return 0;
//}
//指针自己是不可用的，把别人给指针，用指针用别人


//检验结构体中重定义问题
//struct Add
//{
//	int a;
//	char b[15];
//}p,pa,pb;
//
//int main()
//{
//	//struct Add p = {5,"songyucheng"};
//	p = { 5,"songyucheng" };  //不行的
//	return 0;
//}

//#include <stdio.h>
//int main()
//{
//	char a = -1;
//	signed char b = -1;
//	unsigned char c = -1;
//	printf("a=%d,b=%d,c=%d", a, b, c);
//	return 0;
//}

//关于数据类型的定义和打印控制字符串的优先级问题
//#include <stdio.h>
//int main()
//{
//	char a = 128;
//	printf("%u\n", a);
//	return 0;
//}
//4294967168

//#include <stdio.h>
//int main()
//{
//	char a = -128;
//	printf("%u\n", a);
//	return 0;
//}
//4294967168
//int main()
//{
//int i = -20;
//unsigned int j = 10;
//printf("%d\n", i + j);
//return 0;
//}

//10000000  00000000 00000000 00010100原
//11111111  11111111 11111111 11101011反
//11111111  11111111 11111111 11101100补1 （整型提升）
//
          //大错特错就在于正数
//00000000  00000000 00000000 00001010原    即为补码
//11111111  11111111 11111111 11110101反
//11111111  11111111 11111111 11110110补2
//
//11111111  11111111 11111111 11101100补1
//11111111  11111111 11111111 11110110补2
//11111111  11111111 11111111 11100010 补3 (结果)
//
//打印   识别为有符号数  且为负 ， 所以转原码
//11111111  11111111 11111111 11100010 补3
//11111111  11111111 11111111 11100001 反3
//10000000  00000000 00000000 00011110 原3

//00000000  00000000 00000000 00001010补2
//11111111  11111111 11111111 11101100补1
//11111111  11111111 11111111 11110110补3
//10000000  00000000 00000000 00001010     正确结果
//按照补码的形
//int main()
//{
//	unsigned int i;
//for (i = 9; i >= 0; i--) 
//{
//	printf("%u\n", i);
//}
//return 0;
// //死循环
//}

//int main()
//{
//	char a[1000];
//	int i;
//	for (i = 0; i < 1000; i++)
//	{
//		a[i] = -1 - i;
//	}
//	printf("%d", strlen(a));
//	return 0;
//}
//这次思考的时候又错了，用原码算的，
//总结：直接源码的加减方式，在一般情况下可以，但在跨边界的时候就无效了，比如char-127和-128的边界
//或者说那种按源码的方式本省就是投机的，最准确的还是补码算

//int main()
//{
//	char a = -128;
//	char x = a+1;
//	printf("%d", x);
//	int c = 127;
//	int n = c + 1;
//	printf("\n%d", n);
//	return 0;
//}

//测试memcpy 函数
//void *memcpy(void *destination,void *source,sizt_t num)
//int main()
//{
//	int arr[] = { 1,5,1,1,5,2,7,1,5,5,5 };
//	int arr2[20] = { 0 };
//	memcpy(arr2, arr, sizeof(arr));
//	char a[] = "songyucheng";
//	char b[20];
//	memcpy(b, a, sizeof(a));
//	return 0;
//}

//这是他的原型int isxdigit(int c)
//#include<ctype.h>
//int main()
//{
//	int a = 5;
//	if (isxdigit('5'))
//		printf("YES\n"); //为什么传不进去
//	else
//		printf("NO");    //注意这个函数的参数虽然是整形但可以传字符
//	if (isxdigit(12))
//		printf("YES\n");
//	else
//		printf("NO");
//	if (isxdigit(a))
//		printf("YES\n");
//	else
//		printf("NO");
//	if (isxdigit('d'))
//		printf("YES\n");
//	else
//		printf("NO");
//	if (isxdigit('e'))
//		printf("YES\n");
//	else
//		printf("NO");
//	if (isxdigit('a'))
//		printf("YES\n");
//	else
//		printf("NO");
//	return 0;
//
//}


//对于tolower函数的典型错用    ！！！tolower是有返回值的
//#include<ctype.h>
//int main()
//{
//	char A[] = "ABCDefgh";
//	int i = 0;
//	printf("\t%s\n", A);
//	while (A[i] != 0)
//	{
//		if (islower(A[i]))
//		{
//			toupper(A[i]);
//			printf("%c", A[i]);
//		}
//		if (isupper(A[i]))
//		{
//			tolower(A[i]);
//			printf("%c", A[i]);
//		}
//		i++;
//	}printf("\t%s", A);
//	return 0;
//}

//#include<ctype.h>
//int main()
//{
//	char A[] = "ABCDefgh";
//	int i = 0;
//	printf("\t%s\n", A);
//	while (A[i] != 0)
//	{
//		if (islower(A[i]))
//		{
//			printf("%c",toupper(A[i]) );
//		}
//		if (isupper(A[i]))
//		{
//			printf("%c",tolower(A[i]) );
//		}
//		i++;
//	}printf("\t%s", A);
//	return 0;
//}


//实验memcpy函数
//int main()
//{
//	int arr[] = {1,2,3,4,5,6,7,8,9};
//	char zi[50] = "songyu";
//	memcpy(zi, arr, sizeof(arr));
//	//为什么这种更改是不连续的，但又有规律
//
//	return 0;
//}
//关于memcpy函数的有任何重叠，则视为未定义
//我觉得这个重叠应该是指地址上的
//int main()
//{
//	int arr[10] = {1,2,3,5,6,7,9};
//	int arr2[] = {1,2,3,4,6,7,8,9};
//	//高度相似的
//	memcpy(arr, arr2,sizeof(arr2));
//	return 0;
//}

//接下来是和memcpy极其相似的一个函数memmove//
//最大的区别就是memmove不考虑内存重叠的问题
//void *memmove
//int main()
//{
//
//	return 0;
//}

//memcmp
//int memcmp(void *des,void *source,size_tnum)
//int main()
//{
//	int arr[] = { 1,2,3,4,5,6 };
//	int arr2[] = { 1,2,3,4,5,6 ,7,8,9};
//	if (!memcmp(arr, arr2, sizeof(arr)+1))
//		printf("完全一样");
//	return 0;
//}

//模拟实现strlen
//第一种方法       循环
//int my_strlen(char *arr)
//{
//	int i = 0;
//	while(*arr != 0)
//	{
//		i++;
//		arr = arr + 1;
//	}
//	return i;
//}
//int main()
//{
//	char string[] = "songyucheng";
//	printf("%d\n",my_strlen(string));
//	printf("%d\n",strlen(string));
//	return 0;
//}

//第二种方法   递归
//int my_strlen(char *arr)
//{
//	 //static int i = 0;
//	int i = 0;
//	if (*arr != 0)
//	{
//		my_strlen(arr+1);
//		i++;
//	}
//	return i;
//}
//int main()
//{
//	int o = 0;
//	char string[] = "songyucheng";
//	printf("%d\n",o=my_strlen(string));
//	printf("\t%d", strlen(string));
//	return 0;
//}

//我的第二种方法太粗糙了
//int my_strlen(char *arr)
//{
//	if (*arr == 0)
//		return 0;
//	else
//		return 1 + my_strlen(arr+1);
//}
////一段优美的极简代码
//
//int main()
//{
//	int o = 0;
//	char string[] = "songyucheng";
//	printf("%d\n",o=my_strlen(string));
//	printf("\t%d", strlen(string));
//	return 0;
//}

//极简版二
//int my_strlen(char *arr)
//{
//	char *p = arr;
//	while (*p != 0)
//	{
//		p++;
//	}
//	return p - arr;
//}
//
//int main()
//{
//	int o = 0;
//	char string[] = "songyucheng";
//	printf("%d\n",o=my_strlen(string));
//	printf("\t%d", strlen(string));
//	return 0;
//}

//模拟实现strcpy
//void my_strcpy(const char *des,const char *sor)
//{
//	assert(des!=NULL);
//	assert(sor!= NULL);
//	while(((*des!= 0)&&(*sor!= 0)))
//	{
//		*des = *sor; des++; sor++;
//	}
//	
//	if (*sor == 0||(*sor==*des))
//	{
//		*des = 0;
//		printf("拷贝完毕");
//	}
//	if (*des == 0)
//	{
//		printf("目标内存不够");
//	}
//}
//int main()
//{
//	void my_strcpy(char *des, char *sor);
//	char pa[] = "#########################";
//	char pb[] = "songyucheng";
//	printf("%s\n", pa);
//	int num = (sizeof(pb) + 1);
//	my_strcpy(pa, pb);
//	printf("%s\n", pa);
//	return 0;
//}

//极简版
//char *my_strcpy(char *dest, const char*src)
//{
//	char *ret = dest;
//	assert(dest != NULL);
//	assert(src != NULL);
//
//	while ((*dest++ = *src++))
//	{
//		;
//	}
//	return ret;
//}
//他生成的为一个新的组


//实现strcat
//char *def(char *des, const char *sor)
//{
//	assert(des!= NULL);
//	assert(sor!= NULL);
//	while (*des)
//	{
//		des++;
//	}
//	while (*des=*sor)
//	{
//		;
//	}
//	return des;
//}

//实现并模拟实现strstr 
//参数一、参数二都是字符串类型
//int main()
//{
//	char pa[] = "songyucheng";
//	char *a=strstr("songyucheng", "eng");
//	printf("%s", a);
//	return 0;
//}

//char *my_strstr(char *des,const char *sor)
//{
//	assert(des != NULL);
//	assert(sor != NULL);
//	char *ret=des; char *resk = (char *)sor;  //先前const char * 和char *  类型不匹配，可以强制转换 
//	while (*des != 0)
//	{
//		resk = sor;
//		des++;
//		while(*des == *resk)
//	{
//			//ret = des;
//		des++,resk++;
//		
//		if (*resk == 0)
//		{
//			printf("查找成功");
//			return ret;
//		}
//	}
//	}
//	printf("\n查找失败"); return NULL;
//}
//
//int main()
//{
//	char a1[]= "lreallyloveyou";
//	const char a2[]= "love";
//	char *des=my_strstr(a1,a2);
//	printf("%s", des);
//	return 0;
//}

//尝试枚举
//enum mye
//
//{
//	MAX,
//	MIN,
//	MID
//};
//
//int main()
//{
//	printf("%d	%d	%d", MAX, MIN, MID);
//	return 0;
//}

//结构体在声明时定义并初始化
//struct my_s
//{
//	int a;
//	char m[20]; 
//}p = {5,"song"};
//
//int main()
//{
//	printf("%d     %s", p.a, p.m);
//	return 0;
//}

//enum Color//颜色
//{
//	RED = 1,
//	GREEN = 6,
//	BLUE = 4
//};
//int main()
//{
//	enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。
//	clr = 5;
//	printf("%d", clr);
//	return 0;
//}

//#include <stdio.h>
//int main()
//{
//	FILE * pFile;
//	//打开文件
//	pFile = fopen("myfile.txt", "w");
//	//文件操作
//	if (pFile != NULL)
//	{
//		fputs("fopen example", pFile);
//		//关闭文件
//		fclose(pFile);
//	}
//	return 0;
//}

//int main()
//{
//	int arr[3][3] = {1,2,3,4,5,6,7,8,9};
//	printf("%x\n",arr);
//	printf("%x\n",arr+1);
//	printf("%x\n",&arr);
//	printf("%x\n", &arr+1);
//	printf("%d\n",(*arr));
//	printf("%d\n",(**arr)+1);
//	printf("%d\n", *((*arr)+2));
//	return 0;
//}

//typedef struct a1
//{
//	int a;
//	//Pa next;          编译从上到下进行，这里的Pa无效
//	struct a1 * next;
//}P,*Pa;                   //为什么编不过去       没有初始化
//                                   
//int main()
//{
//	int *a;            //a”: 未引用的局部变量
//	struct a1 *head= (Pa)malloc(12);
//	P c = { 5,NULL };
//	Pa tail = (Pa)malloc(12);
//	Pa tem = tail;          //使用了未初始化的局部变量“tail”    没有初始化不可进行赋值操作
//	Pa new= (Pa)malloc(12);
//	head->next = tail;
//	new->next = tem;
//	tail = new;
//	free(new);
//	free(head);
//	free(tail);
//}

//int main()
//{
//	int a = 1;
//	int *p = &a;
//	int *x;
//	x = p;
//	return 0;
//}

//int main()
//{
//	short a = -1;
//	printf("%d\n", a);
//	printf("%u", a);      //4294967295
//	return 0;
//}
//这就告诉我们，打印时只会有整形提升没有截断
//
//int main()
//{
//	char a = '/o12';
//	printf("%d\n", a);
//	printf("%c", a);
//	return 0;
//}

//int main()
//{
//	//int a = b = c = 5;
//	int a, b, c;
//	a = b = c = 5;
//	printf("%d\t%d\t%d",a,b,c );
//	return 0;
//}
//printf("%8.2lf", c);        意思是：指定数列占7行，其中小数占两行

//头文件#include 后加<>和加""的区别    
//<>只查找C编译系统的子目录（标准方式）
//""会先查找用户当前目录，再用标准方式查

//int main()
//{
//	printf("%7.50lf\n",(double)4/3); //333  3333  3333   3333
//	printf("%e\n", 100); //这样的格式是不对的
//	printf("%e\n", 10.0);         //必须有小数点
//	printf("%e\n",123.456);
//	"%o\n", -1);      //直接读内存（补码），以无符号数输出
//	printf("%2s\n", "songyucheng"); //错误格式
//	printf("%.2s", "songyucheng");//正确
//	return 0; printf(
//}

//double   的精确度是小数后15位 ，float是6~7位

//int main()
//{
//	int a = 66;
//	int b = 79;
//	int c = 89;
//	putchar('\101');
//	putchar('\n');
//	putchar('\065');
//	putchar('\n');
//	putchar('\x16');  //22       //o在这里是不可识别的
//	putchar('\16');
//	putchar('\016');
//	putchar('\o16');
//	return 0;
//}

//int main()
//{
//	putchar(putchar(getchar()));
//	/*putchar(getchar());
//	putchar(getchar());
//	putchar(getchar());*/
//	putchar('\n');
//	return 0;
	//1.printf()的返回值是打印字符的个数, 且打印字符串的时候不会加上空字符’\0’ 例...
	//	2.scanf()返回值返回的是成功读取的项数 #include<stdio.h> #...
	//	3.getchar()的返回值是用户输入的第一个字符的ASCII码 #include < ...
	//	4.putchar()的返回值返回的是原字符, 但如果输入一连串字符, 则只会返回第一个字符
//}

//int main()
//{
//	//char a1=putchar((32+getchar()));
//	//printf("\n");
//	//char b1=putchar((32 +'a')); //不合法
//	//printf("\n");
//	char c1 = getchar();
//	putchar(c1+32);         //我想输入B，返回b
//	putchar('b' + 32);    //这样不行， 为什么呢
//	char c2 = c1 + 32;
//	putchar(c2);
//	return 0;
//}
//
//int main()
//{
	//char c1, c2;
	//c1 = 197, c2 = 198;
	//printf("%d       %d", c1, c2);
	//return 0;

	//关系运算符是自左到右执行的
	//int f, a=2, b=5, c=3;
	//f = a<b>c;
	//printf("%d", f);
//	for (int n = 0; n < 2000; n++)
//	{
//		if (n % 4 == 0 && n % 400 == 0 || (n % 4 == 0&&n%100!=0))
//{
//	printf("%d\t", n);
//}
//	}
//
//}

//练手       破译密码
	//int main()
	//{
	//	char c = getchar();
	//	while (c != '\n')
	//	{
	//		if ('w' <= c&&c < 'z' || ('W' <= c&&c < 'Z'))
	//		{
	//			c = c + 4 - 22;
	//		}
	//		if ('a' <= c&&c < 'w' || ('A' <= c&&c < 'W')) c += 4;
	//		putchar(c);
	//		c = getchar();
	//		
	//	}
	//	return 0;
//#include<math.h>
//int main()
//{
//	int n = 0,a=0,num=0;
//	printf("请分别输入n，a的值.>");
//	scanf("%d%d",&n,&a);
//	for (int i = 1; i <= n; i++)
//	{
//		int val = 0; //int b = 2e5;
//		for (int m =1; m <=i; m++)
//		{
//			//val += a*pow(10,m-1);
//			val +=a*1e(m-1);           //这写法过不去
//		}
//		num += val;
//	}
//	return 0;
//}
//
////算法改进        优质
//while (i<=n)
//{
//	fn = fn +a;
//	lm = lm + fn;
//	a *= 10;
//		i++;
//}

//求n!阶层
//int main()
//{
//	long long n = 0; long long count = 0;
//	scanf("%lld",&n);
//	for (int i = 1; i <= n; i++)
//	{
//		long long num = 1;
//		for (int m = 1; m <= i; m++)//这么写的话，也认为num一出for就销毁
//		{
//			num*=m;
//		}
//		count += num;
//	}printf("%lld", count);
//	return 0;             //问题就在于，空间不够      
//}
//4037913     10       4037913.000000
//1443297817  15       1401602636313.000000            5738265113  
//int main()
//{
//	double s = 0, t = 1;
//	int n;
//	for (n = 1; n <= 15; n++)
//	{
//		t = t * n;
//		s = s + t;
//	}
//	printf("%lf", s);
//	return 0;
//}

//int main()
//{
//	double n = 0; double count = 0;
//	scanf("%lf", &n);
//	for (int i = 1; i <= n; i++)
//	{
//		double num = 1;
//		for (int m = 1; m <= i; m++)//这么写的话，也认为num一出for就销毁
//		{
//			num *= m;
//		}
//		count += num;
//	}printf("%lf", count);
//	return 0;             //问题就在于，空间不够      long long的空间还是不够
//}

//递归实现斐波那契数
//int che(int n)
//{
//	if (n < 3)
//		return 1;
//	return che(n - 1) + che(n - 2);
//}
//
//
//int main()
//{
//	int x;
//	scanf("%d", &x);
//	printf("求第x位斐波那契函数");         //22-17711     15-610       20-6765     19-4181    21-10946
//	printf("%d",che(x));
//}

//static关键字的作用:1.修饰变量时，（建议）变量存储在静态区，当函数调用结束后变量內容不消毁
            //       2.但是它使得变量和函数不得跨文件调用，就保证了不同文件间不会有重命名或误用的问题
// ！！       //       3.如果没有初始化，那么static初始化的变量默认为0

// const的作用       1.使得被修饰的量不可被修改
//他出现的目的就是取代预编译指令
 //     没想到的      2.（2）便于进行类型检查，使编译器对处理内容有更多了解
 //                   3.可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改,可以一改全改
//                    4.增强代码健壮性，保护被修饰的东西


//int sqt(int x,int val,int n)
//{
//	
//	if (fabs(val-x)>1e-5)      //首先有类型错误
//	{
//		x=val;
//		val = (x + n / x) / 2;
//		x=sqrt(x,val,n);
//	}
//	return x;
//}
//int main()
//{
//	int n; scanf("%d",&n);
//	printf("\n%d", sqt(n,n,n));
//	return 0;
//}
//#include<math.h>
//double sqt(double x, double val, double n)       //用递归实现开平方
//{
//		x = val;
//		val = (x + n / x) / 2;
//	if (fabs(val - x) > 1e-5)      //首先有类型错误
//	{
//		x = sqrt(x, val, n);
//	}
//	return x;
//}
//int main()
//{
//	double n; scanf("%lf", &n);
//	printf("\n%lf", sqt(n, n, n));
//	return 0;
//}

    //用循环实现开平方
//int main()
//{
//	double x,x1,x2;
//	double w = 1e-5;
//	scanf("%lf", &x);
//	x2 = x,x1=x;           //因为存在一个a为最初的不变量
//	do
//	{
//		x = x1;
//		x1 = (x + x2 / x)/2;
//
//	} while (fabs(x - x1)>1e-5);     //原本有个判断的失误
//	printf("%lf",x1);
//	return 0;
//}


//int main()       //实验 fabs   没问题啊
//{
//	double a= fabs(2 - 3);
//	double b = 100000e-5;       //没问题
//	return 0;
//}

//求方程的根：还有种方法叫牛顿迭代法

//   用计算机来解绝实际问题       绝了
//int main()
//{
//	char a, b, c;
//	for (a = 'x'; a <= 'z'; a++)
//	{
//		for (b = 'x'; b <= 'z'; b++)
//		{
//			if (a != b)
//			{
//				for (c = 'x'; c <= 'z'; c++)
//				{
//					if (a != c && b != c) //&& a != 'z'&&c != 'x'&&c != 'z')
//						if(a != 'x'&&c != 'x'&&c != 'z')
//						printf("A--%c\nB--%c\nC--%c\n", a, b, c);
//				}
//			}
//		}
//	}
//}
    //牢记puts函数不是将结束的标志变为了\n，   而是把\0转变为\n输出
//int main()
//{
//	//char a[20] = { "song yu \0cheng is me" };
//	char a[] = { "0" };
//	char *b=gets(a);
//	puts(b);
//	printf("%s", a); 
//	return 0;              //gets的使用比scanf更简洁，可以直接输入空格
//}


//#include<stdio.h>
//#include<cstring>

//int main()
//{
//	int arr[30][30] = { 0 };
//	int n;
//	scanf("%d", &n);
//	memset(arr, 1, sizeof(arr));
//	for (int i = 0; i < n; i++)
//	{
//		for (int x = 0; x <= i; x++)
//		{
//			//分多种情况讨论1.右边  2.左边  3.中间
//			if(x == 0)
//			{
//				arr[i][x] = 1;
//			}
//			else if (x == i)
//			{
//				arr[i][x] = 1;
//			}
//			else
//			{
//				arr[i][x] = arr[i - 1][x] + arr[i - 1][x - 1];
//			}
//		}
//	}
//	for (int i = 0; i < n; i++)
//	{
//		for (int x = 0; x <= i; x++)
//		{
//			printf("%d ", arr[i][x]);
//		}
//		printf("\n");
//	}
//	return 0;
//}


//#include"hellow_world.h"


//char * mly_printf()
//{
//	char a[] = "Hello, World!";
//	return a;
//}
//#include<stdio.h>
//char* mly_printf(char* x)
//{
//	x="Hello, World!";
//	return x;
//}
//#include"hellow_world.h"
//int main()
//{
//	//void mly_printf();
//	//char *s = mly_print();
//	char a[20];
//	char * p= mly_printf(a);
//	printf("%s",p);
//	//printf("%s", s);
//	return 0;
//}
//#include"hellow_world.h"
//int main()
//{
//	char arr[20] = { 0 };
//	char *s = my_printf(arr);
//	printf("%s", s);
//
//}

//对于&&和||的判断还有些顾虑
//int main()
//{
//	int year;
//	scanf("%d",&year);
//	if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)  //竟然可以过
//	{
//		printf("%d是闰年",year);
//	}
//	return 0;
//}

//int main()
//{
//	char a =0;char b = 5;
//	int c, d;
//	scanf("%sw%s",&a,&b);
//	/*scanf("%dw%d",&c,&d);*/
//	/*scanf("%d", &c, &d);*/
//	//int a, b;
//	//scanf("%d%d", &a, &b);
//	//if (a%b == 0)
//	//	printf("YES");
//	//else
//	//	printf("NO");
//		return 0;
//}

//int main()
//{
//	char a='w';
//	char arr[5] = "love";
//	scanf_s("%c",&a);
//	scanf_s("%s",arr);
//	return 0;
//}

//int main()
//{
//	int arr[1000] = { 0 };
//	for (int i = 1; i < 1000; i += 3)
//	{
//
//		arr[i - 1] = 1;
//	}
//	return 0;
//}

int main()
{
	unsigned a = -10;
	printf("%d\n",a);
	printf("%u",a);
	return 0;
}
















































































































































































































































